Propose a task — something to do; what will be read again is a document (write_doc). Give it a title. Several read from one thread go together in tasks, each judged on its own, so a bad one does not sink the rest. A step is one line of a checklist; work that is several tasks with one end — a move, a release, a plan — goes in parts, one level deep, rather than packed into steps. A ticket's progress, its reviews, pull requests and audits are this task's page and its parts, never documents. Tisty tags it #agent by itself.

Make a task that is already here ring at a given moment. Adds to whatever it rings at already and never takes one away, so a reminder the person set themselves is safe. read says what it carries before you add. Use it for the appointment that was filed without one, and leave alone what repeats — a routine already comes back on its own.

Write the description of a task you filed, or one the person opened to agents: what it is, in the Tisty language. One already there is written over whole, so read it first and keep what still holds; what you learnt on the way goes in note.

Add a checklist, or more of one, to a task you filed or one the person opened to agents. Steps go after the ones already there; read shows them.

Mark steps of a task done when you did them yourself — the moment you did, not at the end. Name each by its text as read shows it; one unknown name and nothing is ticked, and a name two steps share ticks the next one still open. On a task you filed or one the person opened to agents the step is ticked; on any other of the person's it stays unticked, said done, until they take your word. Either way the task stays open until say_done and the person.

Unmark steps an agent ticked that are not done after all, on a task you filed or one the person opened to agents. On any other of the person's tasks it takes back your word on steps you said were done. Only a tick or a word an agent gave can be taken back: one the person gave is theirs, and naming it unticks nothing. Name each step by its text as read shows it. Unticking closes and opens nothing; the task stays as it was.

Give a better title to a task an agent filed. A task the person wrote keeps its title, opened to agents or not.

Rewrite a step that is not ticked, on a task you filed or one the person opened to agents. A ticked step is refused: untick it first if the tick was yours by mistake.

Take off steps that are not ticked, on a task you filed or one the person opened to agents: a step that no longer applies, or one written twice. With to they are not dropped but handed on, added after the steps of the task they belong on. One ticked step among them and nothing is taken off.

On a task you may work on — one an agent filed, or one the person opened to agents. part_of hangs it under another such task as one of its parts, or with null lets it go to stand on its own. list puts a task an agent filed in a better list; a task the person filed keeps its list. One level only: a task with parts is no part, and a part holds none. A closed task, on either side, takes nothing, and a whole said done or not to be done takes no new part until the person decides.

Rewrite a note in the journal of a task you filed or one the person opened to agents, named by the id read shows beside it. The new body replaces the old one whole; a note cannot be emptied.

Append to what a task has recorded. Only a task's: a note set apart inside a document is a callout, > [!NOTE], written with edit_doc. Works on tasks the person wrote too. Use it when something new turns up about work that already exists, instead of filing a duplicate. A closed task is history and takes no note: if the work came back, propose it anew.

Copy a file from this machine into Tisty and keep it in one of two places: name a task and it goes on that task's journal, with where it came from written down beside it; name a doc and it is added at the end of that document, shown there as a picture or a card. An .html or .htm page attached to a document is drawn there as a live widget, sealed like a ```widget block and with the same classes and colours, which suits a page too large to write inline; to show it as a plain card instead, give its reference the title "file": ![name](page-1a2b3c4d.html "file"). One or the other, never both. The file is copied, not linked. A task and a document both take files up to 650 MB — a recording, a video, a slide deck. Only attach what you were asked to.

Write something to keep and read again — a recipe, a procedure, a reference, a summary; work to do is a task (propose). In the Tisty language (language has it whole): Markdown from elsewhere is turned into it on the way in, the answer says what changed under turned, and only what has no way in is refused, naming it. Left alone it writes a new document; with doc and print it writes an existing one again, whole — pages the body does not name keep their lines, put back at the end — except, when compacting, the pages you marked, which leave the body. To change one passage, edit_doc does it without carrying the whole both ways. Before writing a new one, find: a subject that has a document gets edit_doc, or this with doc and print, not a second document; a title carrying a ticket, a date or «v2» is the sign you are writing one, and a title already taken is refused, naming it. With compact it writes a document back into the living shape the instructions give: needs print, keeps the old body for restore_doc, and the answer gives the size before and after and what was kept back. A document is tagged by writing #word in its own text, for what it is about: six is already a lot, past 64 the rest are dropped, and tags lists those in use.

Add to a document that exists, at the end or under a heading you name. What is already written stays exactly as it is — you are adding, never rewriting, so nothing the person wrote can be lost and no print is needed. For what is chronological by nature — a log, minutes, the dated notes on a task's page. For a fact that changed, edit_doc the passage that says the old one: adding the new fact under the old leaves the document saying both. With under you can put a paragraph in the right part of a long document without reading any of it; outline_doc tells you which headings there are. The answer says how many characters it grew by; with echo it hands back the lines around what you added. A task's page takes it too, named by the task's id, on a task an agent filed or one the person opened to agents: what you add goes under the assistant's own notes, dated and signed, never among their words. On a task's page, replace writes the assistant's notes again whole instead of adding.

Undo a write to a document. Changing a passage and replacing a body keep what they replaced, and this puts it back; adding to the end keeps nothing, and neither do the person's own saves. Refused unless the document still reads as that write left it — going back would undo whatever came after — with even_if_more to go back over all of it once you have read the document and know that is what you want. What it puts back is kept in turn, so calling it twice leaves the document where it started, which makes it safe to try. Reach for it the moment a write comes back saying something you did not expect, instead of retyping the document from memory.

Replace one passage of a document with another, named either by what it says with old or by where it sits with section or a line range — which let you change a part of a document you never read. What it said before is kept first, and if that cannot be done the edit is refused rather than made; restore_doc puts it back. The answer says how many characters the document grew by, which is worth reading: an edit should not change the size by much more than what you sent.

Everything written down to consult — not the words a task keeps with it, which come with the task — the one written most recently first, with the folder each one sits in, whether it was put away, whether it is locked, and for each one what it is about: how many words it holds, how many sections, and the words it leans on. That is enough to pick which document to open without opening any of them; the print of the one you go on to edit comes back from read_doc or outline_doc. Ask for it before writing, so you do not write again what is already kept.

Read one markdown file from disk and keep it here as a document, turning on the way in what the Tisty language has no word for into what it can say, and saying what it changed. Every file the text points at beside it — pictures, video, PDFs — is copied in too, and the text is pointed at Tisty's own copies: nothing is left pointing outside. What cannot come in has its link taken out rather than left dangling. The files on disk are left untouched. Nothing is turned away for what it holds: a document carrying what looks like a live credential comes in as written, with a warning at the top for the person to decide about. A task's page brought back hands the task its properties and its words, and makes no document. Takes folder and page_of like write_doc. One file per call — walk an export folder yourself and call it for each, so the person sees what happened to each one.

Write a document out as markdown files in a folder the person can reach, with its pages numbered in reading order and its attachments beside them. Nothing here changes and nothing is deleted: an export is a copy. Use it to hand work to something outside Tisty.

Put a document away when the person asks for that, and bring it back with archived false. «Delete it» is flag_doc instead. Nothing is deleted and no text changes: docs and find reach the archive as well, unless their scope says otherwise. A single page can be put away on its own, and it stays where it lives — under its document, greyed and read-only — rather than moving to the archive. Putting the document away covers its pages too, and bringing it back wakes each page as it was: one that was already apart stays apart. Putting a document away is not the same as finishing a task — a task is the person's to close, and there is no tool here for that.

The tool for «delete this document», and the only one: you cannot delete, so you mark and the person deletes. Mark a document you found is no longer worth keeping — a copy of another, notes folded into a living document, a handover for a flow that was retired — with its reason, where what it said lives now in instead, and in body what makes it old and how you know. Several copies of one thing go in one call, marked alike, so the person settles the set with one click. The mark changes nothing: the document reads the same, stays where it is, and the person sees the mark when they open it. Deleting it and taking the mark off are theirs, from the window; archive_doc puts it away only when they ask for that. One mark at a time — a document already marked is refused until the person has looked, and in a set it is skipped and named.

Move a document into a folder, or out of every folder by leaving folder out. Nothing is deleted and no text changes. Moving is not writing, so a document the archive holds by itself moves too and stays put away: that is how something already archived is filed where it belongs.

Needs doc, or order with page_of. A page is real content related to one subject but not part of it — a runbook, a contract, an annex — never a session: a review, a day's progress or a PR's notes belong on the task. Hang a document from another as one of its pages, or take a page out by leaving page_of out, which makes it a document of its own again, back in the folder it came from. A page goes with its document everywhere — folder, archive and deletion — and holds no pages of its own. Hanging one writes the line that names it at the end of that document, the same line write_doc with page_of writes; after, before and at say where that line goes instead. Taking a page out writes nothing: the line stays where it was, now pointing at a document of its own, and taking it out of the text is yours to do. order is the third thing this does: it takes the pages of one document and deals the lines they already have back out in the order you name, which is how several are put in order in one call. The order pages are read in is the order their lines sit in the document, and nothing else. The line is ![Its title](tisty:doc/its-name), opening bang and all — without it the line is a mention in a sentence and gives the page no place — and a square bracket in the title goes in with a backslash before it.

Make a folder for documents, and give it an icon and a colour if they fit. If a folder by that name is already there it is used as it is — and without inside, one by that name is found however deep it sits, so a name you mean as a new top-level folder may hand you one inside another. An icon or colour you send changes how it looks; nothing is renamed, moved or deleted. Folders hold documents, not tasks; tasks go in lists.

The text of a document and the print it reads at. Left alone it brings the whole body; one past about 12,000 characters comes back as its outline instead, with whole set to false, and then you ask for a section, a run of lines or a budget of chars, about 12,000 at a time. Reading a part is the ordinary way to work: the print comes with every answer, so a passage can be changed with edit_doc without ever bringing the rest. pages_loose names the pages no line in the body names.

One call to start on: the lists, the folders, the tags already in use, how much there is, the documents written most recently, and a cursor. Send that cursor back as since next time and what moved comes with it — the tasks touched and the documents written, whoever did it — beside the lists, the folders and the tags, which come every time. It is meant to be the first thing you ask and the thing you ask again when you come back, in place of lists and tags and a blind docs.

Change the date or the deadline of a task an agent proposed, when what you learnt since moves it: the meeting slipped a week, the document arrived early. It reaches only what an agent filed — a day the person set is theirs, and naming one of their tasks is refused. Send null to take a day off. Nothing else about the task changes, and closing it is still never yours.

Say that a task is done, when you did the work yourself — any task of the person's too, since it is only your word. Say it in the turn the work ends. Every step has to be ticked or said done first; with one left it is refused, and so is a whole with a part still open and unmarked. Reading that it no longer matters is not doing it, and goes in say_not_doing. It closes nothing: the task stays open, marked, until the person finishes it or takes the mark off. Say it once; if they have not looked yet, what is new goes in note too.

Say that a task will not be done — it no longer matters, something else made it moot — on any task, the person's too, since it is only your word. Unticked steps do not stop it. It drops nothing: the task stays open, marked, until the person drops it or takes the mark off. Say it once; what is new after that goes in note.

Leave what you worked out about a document, so the next agent — or you, next week — does not have to read it again to know whether it is the one. A summary of what it says, notes for what somebody working with it should know. Kept on this machine only: it never syncs, it is not part of the document, and the person does not see it. Stored against the text as it reads now, so a later write marks it as describing an older version. Write it after reading a long document, never instead of reading one, and write what the document says rather than what you would like it to say: the next agent will act on this without opening the document.

The headings of a document with the lines each one spans and how many characters it holds, how long the whole is, its print, and for a document with pages a row per page with its title, length and sections, in reading order — a few hundred tokens instead of the bodies. Ask for this first when a document is long or when you only mean to change one part of it: with the outline you know which section to read and what it costs, and with the print you can write into it without having read it at all. It also says which other documents point at this one, which is what you want to know before putting it away: those links go on pointing at it in the archive. by says whether an agent or the person began it and each page, alike names documents elsewhere whose title names the same subject as this one or one of its pages, and repeated the headings written in more than one page — the signs that it wants compacting. dead lists the links that lead nowhere, mislabeled the page lines showing another name than the page's title, and a page marked loose has no line naming it, so the window gives it no place.

Everything one task holds: its description, its steps, its journal — each note with the id reword_note takes — its parts, what it keeps, and its document: the page the person reads and writes, with its sections and their grey hints, its boxes ticked as the steps are and its properties written at the top. Ask for it before adding a note, so you do not write down something already written, and before mending anything, so you change what is there now. With fields it brings only the parts you name, which is how to check one thing about a task whose journal is long. A closed task comes with closed and a notice, and reads as it ended: it is history to consult, and nothing on it changes. find with part_of brings the parts of any task, closed or open.

Search the tasks — open and archived alike — and the documents: by words with query, by what a task is with the sifting fields (alone or narrowing a query), or by source alone to see whether something was filed from it already. A task found by what its page, description, steps or notes say comes with in and the line that says it, so a past decision often reads without read. With doc it searches inside that one document instead and hands back the matching lines with their numbers and the section each sits in.

The names of the person's lists, so you can file a task into one. You cannot make a list; anything you propose without one lands in the inbox.

The rules for working in Tisty, one short guide at a time. Left alone it gives the basics — task or document, whose words count, speaking in titles, updating before adding — and an index of the rest. Ask for the guide your next step needs: «tasks» before filing or working a task, «documents» before writing or changing a document, «tidying» before putting things back in order, consolidating or compacting. «all» gives every rule at once.

Plain Markdown needs nothing from here: Tisty takes it as it is and turns it on the way in. Left alone this gives the index of what Tisty adds — pens and their colours, underline, icons, callouts, collapsible sections, tags, cards to other documents, attachments, references, diagrams — apart from what reads as Markdown anywhere. Ask with a topic for the one you mean to write, so a pen colour or an icon is one Tisty knows; «all» gives the whole guide. lang picks English or Spanish; the language itself is the same.

Every tag the person already writes, the most used first, with how many times each one appears, in the plain form they are filed under. Capitals and accents decide nothing: #Camión and #camion are one tag. Ask for it before you tag anything and reuse one when the subject really is the same; a second word for something already tagged splits it in two.